home *** CD-ROM | disk | FTP | other *** search
/ User's Choice Windows CD / User's Choice Windows CD (CMS Software)(1993).iso / utility2 / wclib.zip / WCLIBC.ZIP / WCLIB.C < prev    next >
C/C++ Source or Header  |  1993-04-22  |  34KB  |  987 lines
  1. //===========================================================
  2. // WCLib - A function library for the WinCmd language
  3. // Copyright (C) 1993 Douglas Boling
  4. //===========================================================
  5. // Returns no. of elements
  6. #define dim(x) (sizeof(x) / sizeof(x[0]))   
  7. #define MAXREADLINE       1024   
  8. //
  9. // Defines to reduce number of includes
  10. //
  11. #define NOCOMM             1    Comm driver APIs and definitions
  12. #define NOMINMAX           1    min() and max() macros
  13. #define NOLOGERROR         1    LogError() and related definitions
  14. #define NOPROFILER         1    Profiler APIs
  15. #define NORESOURCE         1    Resource management
  16. #define NOATOM             1    Atom management
  17. #define NOLANGUAGE         1    Character test routines
  18. #define NODBCS             1    Double-byte character set routines
  19. #define NOKEYBOARDINFO     1    Keyboard driver routines
  20. #define NOGDICAPMASKS      1    GDI device capability constants
  21. #define NOCOLOR            1    COLOR_#define color values
  22. #define NOGDIOBJ           1    GDI pens, brushes, fonts
  23. #define NODRAWTEXT         1    DrawText() and related definitions
  24. #define NOTEXTMETRIC       1    TEXTMETRIC and related APIs
  25. #define NOSCALABLEFONT     1    Truetype scalable font support
  26. #define NOBITMAP           1    Bitmap support
  27. #define NORASTEROPS        1    GDI Raster operation definitions
  28. #define NOMETAFILE         1    Metafile support
  29. #define NOSYSTEMPARAMSINFO 1    SystemParametersInfo() and SPI_#define definitions
  30. #define NOMSG              1    APIs and definitions that use MSG structure
  31. #define NOWINSTYLES        1    Window style definitions
  32. #define NODEFERWINDOWPOS   1    DeferWindowPos and related definitions
  33. #define NOVIRTUALKEYCODES  1    VK_* virtual key codes
  34. #define NOKEYSTATES        1    MK_* message key state flags
  35. #define NOWH               1    SetWindowsHook and related WH_* definitions
  36. #define NOMENUS            1    Menu APIs
  37. #define NOSCROLL           1    Scrolling APIs and scroll bar control
  38. #define NOICONS            1    IDI_* icon IDs
  39. #define NOMB               1    MessageBox and related definitions
  40. #define NOSYSCOMMANDS      1    WM_SYSCOMMAND SC_* definitions
  41. #define NOMDI              1    MDI support
  42. //#define NOCTLMGR           1    Control management and controls
  43. #define NOHELP             1    Help support
  44. //
  45. // Sections of windows.h required for compile
  46. //
  47. //#define NOLSTRING          1    lstr* string management routines
  48. //#define NODRIVERS          1    Installable driver APIs and definitions
  49. //#define NOMEMMGR           1    Local and global memory management
  50. //#define NOLFILEIO          1    _l* file I/O routines
  51. //#define NOOPENFILE         1    OpenFile and related definitions
  52. //#define NOSYSMETRICS       1    GetSystemMetrics() and related SM_#define definitions
  53. //#define NOWINOFFSETS       1    Get/SetWindowWord/Long offset definitions
  54. //#define NOSHOWWINDOW       1    ShowWindow and related definitions
  55. //#define NOCLIPBOARD        1    Clipboard APIs and definitions
  56. //#define NOWINMESSAGES      1    WM_* window messages
  57.  
  58. #include "windows.h"
  59. #include "shellapi.h"
  60. #include "mmsystem.h"
  61.  
  62. #include "stdlib.h"
  63. #include "string.h"
  64. #include "direct.h"
  65. #include "dos.h"
  66.  
  67. #include "WinCmd.h"
  68. #include "wclib.h"
  69.  
  70. typedef struct {
  71.     BYTE    bWidth;
  72.     BYTE    bHeight;
  73.     BYTE    bColorCount;
  74.     BYTE    bReserved;
  75.     WORD    wPlanes;
  76.     WORD    wBitCount;
  77.     DWORD    dwBytesInRes;            
  78.     DWORD    dwImageOffset;
  79. } ICONDIRENTRY;
  80. typedef ICONDIRENTRY FAR *LPICONDIRENTRY;
  81.  
  82. typedef struct {
  83.    WORD                idReserved;
  84.    WORD                idType;
  85.    WORD                idCount;
  86.    ICONDIRENTRY    idEntries[];
  87. } ICONHEADER;
  88. typedef ICONHEADER FAR *LPICONHEADER;
  89.  
  90.  
  91. typedef struct {
  92.     char        *szName;
  93.     PLFUNC    Fxn;
  94. } LIBFUNCSTRUCT;
  95. typedef LIBFUNCSTRUCT *PLIBFUNCSTRUCT;
  96.  
  97. INT LibHiWord (LPTOKEN, LPTOKEN);
  98. INT LibLowWord (LPTOKEN, LPTOKEN);
  99. INT LibMoveWin (LPTOKEN, LPTOKEN);
  100. INT LibSizeWin (LPTOKEN, LPTOKEN);
  101. INT LibMinimizeWin (LPTOKEN, LPTOKEN);
  102. INT LibZoomWin (LPTOKEN, LPTOKEN);
  103. INT LibRestoreWin (LPTOKEN, LPTOKEN);
  104. INT LibGetWinHandle (LPTOKEN, LPTOKEN);
  105. INT LibGetWinText (LPTOKEN, LPTOKEN);
  106. INT LibGetWinPos (LPTOKEN, LPTOKEN);
  107. INT LibGetWinSize (LPTOKEN, LPTOKEN);
  108. INT LibGetWinState (LPTOKEN, LPTOKEN);
  109. INT LibGetWindow (LPTOKEN, LPTOKEN);
  110. INT LibGetWinEXE (LPTOKEN, LPTOKEN);
  111. INT LibPostMessage (LPTOKEN, LPTOKEN);
  112. INT LibSendMessage (LPTOKEN, LPTOKEN);
  113. INT LibSendMCIString (LPTOKEN, LPTOKEN);
  114. INT LibGetMCIErrString (LPTOKEN, LPTOKEN);
  115. INT LibFileOpen (LPTOKEN, LPTOKEN);
  116. INT LibFileRead (LPTOKEN, LPTOKEN);
  117. INT LibFileReadLine (LPTOKEN, LPTOKEN);
  118. INT LibFileWrite (LPTOKEN, LPTOKEN);
  119. INT LibFileWriteLine (LPTOKEN, LPTOKEN);
  120. INT LibFileSeek (LPTOKEN, LPTOKEN);
  121. INT LibFileClose (LPTOKEN, LPTOKEN);
  122. INT LibFileExist (LPTOKEN, LPTOKEN);
  123. INT LibGetClipText (LPTOKEN, LPTOKEN);
  124. INT LibSetClipText (LPTOKEN, LPTOKEN);
  125. INT LibSetWinIcon (LPTOKEN, LPTOKEN);
  126. INT LibLoadIconFile (LPTOKEN, LPTOKEN);
  127. INT LibGetCWD (LPTOKEN, LPTOKEN);
  128. INT LibChDrive (LPTOKEN, LPTOKEN);
  129.  
  130. //-----------------------------------------------------------
  131. // Global data
  132. //-----------------------------------------------------------
  133. char     szDllName[] = "WCLib";
  134. char     szTemp[256];
  135. UINT        wWCLibVer = 10;
  136. FIND_T    fs;
  137.  
  138. HANDLE    hInst;
  139. HWND        hMain;
  140. RECT        rect;
  141. BYTE        nIconWidth, nIconHeight;
  142.  
  143. LIBFUNCSTRUCT FuncList[] = {
  144. //   Name          Function
  145.     {"GETWINDOWHANDLE", LibGetWinHandle},
  146.     {"GETWINDOWTEXT", LibGetWinText},
  147.     {"GETWINDOWPOS", LibGetWinPos},
  148.     {"GETWINDOWSIZE", LibGetWinSize},
  149.     {"GETWINDOWSTATE", LibGetWinState},
  150.     {"GETWINDOW", LibGetWindow},
  151.     {"GETWINDOWEXE", LibGetWinEXE},
  152.     {"SIZEWINDOW", LibSizeWin},
  153.     {"MINIMIZEWINDOW", LibMinimizeWin},
  154.     {"MAXIMIZEWINDOW", LibZoomWin},
  155.     {"RESTOREWINDOW", LibRestoreWin},
  156.     {"MOVEWINDOW", LibMoveWin},
  157.     {"POSTMESSAGE", LibPostMessage},
  158.     {"SENDMESSAGE", LibSendMessage},
  159.     {"SENDMCISTRING", LibSendMCIString},
  160.     {"GETMCIERRORSTRING", LibGetMCIErrString},
  161.     {"FILEOPEN", LibFileOpen},
  162.     {"FILEREAD", LibFileRead},
  163.     {"FILEREADLINE", LibFileReadLine},
  164.     {"FILEWRITE", LibFileWrite},
  165.     {"FILEWRITELINE", LibFileWriteLine},
  166.     {"FILEMOVEPTR", LibFileSeek},
  167.     {"FILECLOSE", LibFileClose},
  168.     {"FILEEXIST", LibFileExist},
  169.     {"GETCLIPTEXT", LibGetClipText},
  170.     {"SETCLIPTEXT", LibSetClipText},
  171.     {"LOADICONFILE", LibLoadIconFile},
  172.     {"SETICON", LibSetWinIcon},
  173.     {"HIGHWORD", LibHiWord},
  174.     {"LOWWORD", LibLowWord},
  175.     {"GETDIR", LibGetCWD},
  176.     {"SETDRIVE", LibChDrive},
  177. };
  178. LPCBTOKFUNC    lpCallbackTokenFunction;
  179.  
  180. //===========================================================
  181. // Library initialization and terminataion functions
  182. //===========================================================
  183. //-----------------------------------------------------------
  184. // LibMain - DLL initialization routine
  185. //-----------------------------------------------------------
  186. INT CALLBACK LibMain (HANDLE hInstance, WORD wDataSeg, 
  187.                       WORD wHeapSize, LPSTR lpszCmdLine) {
  188.     hInst = hInstance;
  189.     nIconWidth = (BYTE) GetSystemMetrics (SM_CXICON);
  190.     nIconHeight = (BYTE) GetSystemMetrics (SM_CYICON);
  191.     return 1;
  192. }
  193. //-----------------------------------------------------------
  194. // WEP - DLL termination routine
  195. //-----------------------------------------------------------
  196. INT CALLBACK WEP (int nParameter) {
  197.     return 1;
  198. }
  199. //===========================================================
  200. // Library exported functions
  201. //===========================================================
  202. //-----------------------------------------------------------
  203. // WCLibLoad - Routine called by WinCmd at function lib load
  204. //-----------------------------------------------------------
  205. INT CALLBACK WCLibLoad (HWND hWinCmdWnd, INT sNewLibID, INT sLibErrNum) {
  206.  
  207.    return 0;
  208. }   
  209. //-----------------------------------------------------------
  210. // WCLibReset - Routine called by WinCmd to reset lib
  211. //-----------------------------------------------------------
  212. INT CALLBACK WCLibReset (INT sLibID, LPCBTOKFUNC lpfnCBTokenFunc) {
  213.    INT    i, sRC = 0;
  214.  
  215.     // Add Functions to token list
  216.    for (i = 0; i < dim (FuncList); i++) {
  217.         sRC = (INT) (*lpfnCBTokenFunc) (CBF_ADDTOKEN, 0, 
  218.                             (LPSTR) FuncList[i].szName, 
  219.                             TTYPE_LIBFUNC, 0, MAKELONG (i, sLibID));
  220.         if (sRC) break;
  221.     }    
  222.     return 0;
  223. }
  224. //-----------------------------------------------------------
  225. // WCLibFunc - Routine called by WinCmd at function dispatch
  226. //-----------------------------------------------------------
  227. INT CALLBACK WCLibFunc (LPLINETOKEN *lpltLine, LPTOKEN lptDest, UINT wFuncNum,
  228.                         FARPROC lpfnCBTokenFunc, HWND hWin) {
  229.     INT    sRC;
  230.     lpCallbackTokenFunction = (LPCBTOKFUNC) lpfnCBTokenFunc;
  231.     hMain = hWin;
  232.    lptDest->ucType = TTYPE_NUM;
  233.     sRC = (FuncList[wFuncNum].Fxn) (lptDest, (LPTOKEN)lptDest->dwData);
  234.    return sRC;
  235. }
  236. //-----------------------------------------------------------
  237. // WCGetErrStr - Routine that returns a string for an error
  238. // code.
  239. //-----------------------------------------------------------
  240. INT CALLBACK WCGetErrStr (INT sError, LPSTR lpszStrOut, INT sStrSize) {
  241.    return 0;
  242. }   
  243. //-----------------------------------------------------------
  244. // WCGetHelp - Routine that returns a help string for a function.
  245. //-----------------------------------------------------------
  246. INT CALLBACK WCGetHelp (INT sLineNum, LPSTR lpszStrOut, INT sStrSize) {
  247.  
  248.     if (LoadString (hInst, sLineNum + HELPSTART, lpszStrOut, sStrSize))
  249.         return 1;
  250.     return 0;
  251. }   
  252. //-----------------------------------------------------------
  253. // WCGetVersion - Routine returns lib name and version
  254. //-----------------------------------------------------------
  255. INT CALLBACK WCGetVersion (LPWORD lpwVersion, LPSTR lpszNameOut, INT sStrSize) {
  256.    *lpwVersion = wWCLibVer;
  257.    if (strlen (szDllName) < (UINT) sStrSize)
  258.       lstrcpy (lpszNameOut, szDllName);
  259.    return 0;
  260. }   
  261. //===========================================================
  262. // Local procedures
  263. //===========================================================
  264. //------------------------------------------------------------
  265. // SetToken - Sets a token to a new value
  266. //------------------------------------------------------------ 
  267. INT SetToken (LPTOKEN lptDest, BYTE ucNewType, UINT wData, DWORD dwData) {
  268.    return (INT) (*lpCallbackTokenFunction) (CBF_SETTOKEN, lptDest, 
  269.                                0, ucNewType, wData, dwData);
  270. }   
  271.  
  272. //-----------------------------------------------------------
  273. // GetTokenString - Returns a pointer to the string value
  274. // for a token.
  275. //-----------------------------------------------------------
  276. LPSTR GetTokenString (LPTOKEN lptDest) {
  277.    return (LPSTR) (*lpCallbackTokenFunction)(CBF_GETTOKENSTRING, 
  278.                                              lptDest, 0, 0, 0, 0);
  279. }      
  280. //-----------------------------------------------------------
  281. // GetTokenVal - Returns a pointer to the numberic value
  282. // for a token.
  283. //----------------------------------------------------------- 
  284. LONG GetTokenVal (LPTOKEN lptDest) {
  285.    return (LONG) (*lpCallbackTokenFunction)(CBF_GETTOKENVAL, 
  286.                                             lptDest, 0, 0, 0, 0);
  287. }      
  288. //===========================================================
  289. // WCLib functions
  290. //===========================================================
  291. //------------------------------------------------------------
  292. // LibHiWord - Returns the upper 16 bits of a long
  293. // Arg 1 - Long word
  294. //------------------------------------------------------------ 
  295. INT LibHiWord (LPTOKEN lptDest, LPTOKEN lptArg) {
  296.     if (lptDest->wData <= 1) 
  297.         return ERR_TOO_FEW_PARMS;
  298.     return SetToken (lptDest, TTYPE_NUM, 0, GetTokenVal (lptArg-1) >> 16);
  299. }      
  300. //------------------------------------------------------------
  301. // LibLowWord - Returns the lower 16 bits of a long
  302. // Arg 1 - Long word
  303. //------------------------------------------------------------ 
  304. INT LibLowWord (LPTOKEN lptDest, LPTOKEN lptArg) {
  305.     if (lptDest->wData <= 1) 
  306.         return ERR_TOO_FEW_PARMS;
  307.     return SetToken (lptDest, TTYPE_NUM, 0, GetTokenVal (lptArg-1) & 0xffff);
  308. }      
  309. //------------------------------------------------------------
  310. // GetWinHandle - Returns the window handle from the window
  311. // text.
  312. // Arg 1 - Window title text
  313. //------------------------------------------------------------ 
  314. INT LibGetWinHandle (LPTOKEN lptDest, LPTOKEN lptArg) {
  315.     HWND        hWndTarg;
  316.     
  317.     if (lptDest->wData <= 1) 
  318.         return ERR_TOO_FEW_PARMS;
  319.     hWndTarg = FindWindow (0, GetTokenString(lptArg-1));
  320.     return SetToken (lptDest, TTYPE_NUM, 0, (DWORD)hWndTarg);
  321. }      
  322. //------------------------------------------------------------
  323. // GetWinText - Returns the window text for a window
  324. // Arg 1 - Window handle
  325. //------------------------------------------------------------ 
  326. INT LibGetWinText (LPTOKEN lptDest, LPTOKEN lptArg) {
  327.     HWND        hWndTarg;
  328.     
  329.     if (lptDest->wData <= 1) 
  330.         return ERR_TOO_FEW_PARMS;
  331.    hWndTarg = (HWND) GetTokenVal (lptArg-1);
  332.    szTemp[0] = '\0';
  333.    SendMessage (hWndTarg, WM_GETTEXT, sizeof (szTemp), (DWORD)(LPSTR) szTemp);
  334.         return SetToken (lptDest, TTYPE_STR, 0, (DWORD)(LPSTR)szTemp);
  335. }      
  336. //-----------------------------------------------------------
  337. // LibMoveWin - Function to move a window
  338. // Arg 1 - Window handle
  339. // Arg 2 - New Horizonal pos
  340. // Arg 3 - New Vertical pos
  341. //----------------------------------------------------------- 
  342. INT LibMoveWin (LPTOKEN lptDest, LPTOKEN lptArg) {
  343.    INT        sRC = 0, sNewX, sNewY;
  344.    HWND     hwndTarg;
  345.    
  346.     if (lptDest->wData <= 3) 
  347.         return ERR_TOO_FEW_PARMS;
  348.  
  349.    sNewX = (INT) GetTokenVal (lptArg-2);
  350.    sNewY = (INT) GetTokenVal (lptArg-3);
  351.    hwndTarg = (HWND) GetTokenVal (lptArg-1);
  352.     if (!IsWindow (hwndTarg)) 
  353.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  354.  
  355.     SetWindowPos (hwndTarg, 0, sNewX, sNewY, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
  356.     sRC = SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  357.       return sRC;
  358. }      
  359. //-----------------------------------------------------------
  360. // LibSizeWin - Function to change the size of a window
  361. // Arg 1 - Window handle
  362. // Arg 2 - New Horizonal size
  363. // Arg 3 - New Vertical size
  364. //----------------------------------------------------------- 
  365. INT LibSizeWin (LPTOKEN lptDest, LPTOKEN lptArg) {
  366.    INT        sRC = 0, sNewX, sNewY;
  367.    HWND     hwndTarg;
  368.    
  369.     if (lptDest->wData <= 3) 
  370.         return ERR_TOO_FEW_PARMS;
  371.  
  372.    sNewX = (INT) GetTokenVal (lptArg-2);
  373.    sNewY = (INT) GetTokenVal (lptArg-3);
  374.    hwndTarg = (HWND) GetTokenVal (lptArg-1);
  375.     if (!IsWindow (hwndTarg)) 
  376.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  377.  
  378.     SetWindowPos (hwndTarg, 0, 0, 0, sNewX, sNewY, SWP_NOMOVE | SWP_NOZORDER);
  379.     sRC = SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  380.       return sRC;
  381. }
  382. //-----------------------------------------------------------
  383. // LibMinimizeWin - Function to minimize a window
  384. // Arg 1 - Window handle
  385. //----------------------------------------------------------- 
  386. INT LibMinimizeWin (LPTOKEN lptDest, LPTOKEN lptArg) {
  387.    HWND     hwndTarg;
  388.    
  389.     if (lptDest->wData <= 1) 
  390.         return ERR_TOO_FEW_PARMS;
  391.  
  392.    hwndTarg = (HWND) GetTokenVal (lptArg-1);
  393.     if (!IsWindow (hwndTarg)) 
  394.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  395.  
  396.     if (!IsIconic (hwndTarg)) 
  397.         ShowWindow (hwndTarg, SW_MINIMIZE);
  398.  
  399.     return SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  400. }
  401. //-----------------------------------------------------------
  402. // LibZoomWin - Function to maximize a window
  403. // Arg 1 - Window handle
  404. //----------------------------------------------------------- 
  405. INT LibZoomWin (LPTOKEN lptDest, LPTOKEN lptArg) {
  406.    HWND     hwndTarg;
  407.    
  408.     if (lptDest->wData <= 1) 
  409.         return ERR_TOO_FEW_PARMS;
  410.  
  411.    hwndTarg = (HWND) GetTokenVal (lptArg-1);
  412.     if (!IsWindow (hwndTarg)) 
  413.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  414.  
  415.     if (!IsZoomed (hwndTarg)) 
  416.         ShowWindow (hwndTarg, SW_SHOWMAXIMIZED);
  417.  
  418.     return SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  419. }
  420. //-----------------------------------------------------------
  421. // LibRestoreWin - Function to restore a window
  422. // Arg 1 - Window handle
  423. //----------------------------------------------------------- 
  424. INT LibRestoreWin (LPTOKEN lptDest, LPTOKEN lptArg) {
  425.    HWND     hwndTarg;
  426.    
  427.     if (lptDest->wData <= 1) 
  428.         return ERR_TOO_FEW_PARMS;
  429.  
  430.    hwndTarg = (HWND) GetTokenVal (lptArg-1);
  431.     if (!IsWindow (hwndTarg)) 
  432.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  433.  
  434.     if (IsZoomed (hwndTarg) || IsIconic (hwndTarg)) 
  435.         ShowWindow (hwndTarg, SW_RESTORE);
  436.  
  437.     return SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  438. }
  439. //-----------------------------------------------------------
  440. // LibGetWinPos - Function that returns a window's position
  441. // Arg 1 - Window handle
  442. //----------------------------------------------------------- 
  443. INT LibGetWinPos (LPTOKEN lptDest, LPTOKEN lptArg) {
  444.    INT        sRC = 0;
  445.    HWND     hwndTarg;
  446.    
  447.     if (lptDest->wData <= 1) 
  448.         return ERR_TOO_FEW_PARMS;
  449.  
  450.    hwndTarg = (HWND) GetTokenVal (lptArg-1);
  451.     if (!IsWindow (hwndTarg)) 
  452.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  453.  
  454.     GetWindowRect (hwndTarg, &rect);
  455.     sRC = SetToken (lptDest, TTYPE_NUM, 0, MAKELONG (rect.left, rect.top));
  456.       return sRC;
  457. }
  458. //-----------------------------------------------------------
  459. // LibGetWinSize - Function that returns a window's size
  460. // Arg 1 - Window handle
  461. //----------------------------------------------------------- 
  462. INT LibGetWinSize (LPTOKEN lptDest, LPTOKEN lptArg) {
  463.    INT        sRC = 0;
  464.    HWND     hwndTarg;
  465.    
  466.     if (lptDest->wData < 1) 
  467.         return ERR_TOO_FEW_PARMS;
  468.  
  469.    hwndTarg = (HWND) GetTokenVal (lptArg-1);
  470.     if (!IsWindow (hwndTarg)) 
  471.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  472.  
  473.     GetWindowRect (hwndTarg, &rect);
  474.     sRC = SetToken (lptDest, TTYPE_NUM, 0, 
  475.                     MAKELONG (rect.right-rect.left, rect.bottom-rect.top));
  476.       return sRC;
  477. }
  478. //-----------------------------------------------------------
  479. // LibGetWinState - Function returns icon/restore/zoomed state
  480. // of a window
  481. // Arg 1 - Window handle
  482. //----------------------------------------------------------- 
  483. INT LibGetWinState (LPTOKEN lptDest, LPTOKEN lptArg) {
  484.    HWND     hwndTarg;
  485.    
  486.     if (lptDest->wData <= 1) 
  487.         return ERR_TOO_FEW_PARMS;
  488.  
  489.    hwndTarg = (HWND) GetTokenVal (lptArg-1);
  490.     if (!IsWindow (hwndTarg)) 
  491.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  492.  
  493.     if (IsIconic (hwndTarg))
  494.         return SetToken (lptDest, TTYPE_NUM, 0, 2);
  495.     if (IsZoomed (hwndTarg))
  496.         return SetToken (lptDest, TTYPE_NUM, 0, 3);
  497.  
  498.     return SetToken (lptDest, TTYPE_NUM, 0, 1);
  499. }
  500. //------------------------------------------------------------
  501. // LibGetWindow - Predefined func that returns the Prev, Next,
  502. // owner, and child info on windows.
  503. // Arg 1 - Window handle
  504. // Arg 2 - Relationship
  505. //------------------------------------------------------------ 
  506. INT LibGetWindow (LPTOKEN lptDest, LPTOKEN lptArg) {
  507.     HWND        hWndTarg;
  508.     UINT     wWinSel;
  509.     
  510.     if (lptDest->wData <= 2) 
  511.         return ERR_TOO_FEW_PARMS;
  512.    hWndTarg = (HWND) GetTokenVal (lptArg-1);
  513.     wWinSel = (WORD) GetTokenVal (lptArg-2);
  514.  
  515.     if (!IsWindow (hWndTarg)) 
  516.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  517.     if (wWinSel < 6) {
  518.         hWndTarg = GetWindow (hWndTarg, wWinSel);
  519.     } else
  520.         hWndTarg = GetParent (hWndTarg);
  521.     return SetToken (lptDest, TTYPE_NUM, 0, (DWORD) hWndTarg);
  522. }      
  523. //------------------------------------------------------------
  524. // LibGetWinEXE - Predefined func that returns the name of the
  525. // EXE that created a window
  526. // Arg 1 - Window handle
  527. //------------------------------------------------------------ 
  528. INT LibGetWinEXE (LPTOKEN lptDest, LPTOKEN lptArg) {
  529.     HWND        hWndTarg;
  530.     
  531.     if (lptDest->wData <= 1) 
  532.         return ERR_TOO_FEW_PARMS;
  533.    hWndTarg = (HWND) GetTokenVal (lptArg-1);
  534.  
  535.     if (IsWindow (hWndTarg)) {
  536.             GetModuleFileName (GetWindowWord (hWndTarg, GWW_HINSTANCE),
  537.                                szTemp, sizeof (szTemp));
  538.             return SetToken (lptDest, TTYPE_STR, 0, (DWORD)(LPSTR) szTemp);
  539.     }
  540.     return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  541. }      
  542. //-----------------------------------------------------------
  543. // File support routines
  544. //-----------------------------------------------------------
  545. //-----------------------------------------------------------
  546. // LibFileExist - Function to test for file existance
  547. // Arg 1 - File name
  548. //----------------------------------------------------------- 
  549. INT LibFileExist (LPTOKEN lptDest, LPTOKEN lptArg) {
  550.    INT        sRC;
  551.  
  552.     if (lptDest->wData <= 1) 
  553.         return ERR_TOO_FEW_PARMS;
  554.  
  555.     lstrcpy (szTemp, GetTokenString (lptArg-1));
  556.     sRC = _dos_findfirst (szTemp, _A_HIDDEN | _A_SYSTEM | 
  557.                          _A_RDONLY | _A_SUBDIR | _A_ARCH, &fs);
  558.     if (sRC == 0)
  559.         sRC = SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  560.     else
  561.         sRC = SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  562.       return sRC;
  563. }      
  564. //-----------------------------------------------------------
  565. // LibFileOpen - Function to open a file
  566. // Arg 1 - File name
  567. //----------------------------------------------------------- 
  568. INT LibFileOpen (LPTOKEN lptDest, LPTOKEN lptArg) {
  569.    INT        sRC = 0;
  570.    UINT        wFlags;
  571.    HFILE        hFile;
  572.     OFSTRUCT    of;
  573.    
  574.     if (lptDest->wData <= 2) 
  575.         return ERR_TOO_FEW_PARMS;
  576.  
  577.    wFlags = (UINT)GetTokenVal (lptArg-2);
  578.     hFile = OpenFile (GetTokenString(lptArg-1), &of, wFlags);
  579.     if (hFile != 0)
  580.         sRC = SetToken (lptDest, TTYPE_NUM, 0, (DWORD) hFile);
  581.     else
  582.         sRC = SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  583.       return sRC;
  584. }      
  585. //-----------------------------------------------------------
  586. // LibFileRead - Reads data from a file
  587. // Arg 1 - File handle
  588. // Arg 2 - Amount of data to read
  589. //----------------------------------------------------------- 
  590. INT LibFileRead (LPTOKEN lptDest, LPTOKEN lptArg) {
  591.    INT        sRC = 0;
  592.    UINT        i, wAmount;
  593.    HFILE        hFile;
  594.    PBYTE        pbData;
  595.    
  596.     if (lptDest->wData <= 2)
  597.         return ERR_TOO_FEW_PARMS;
  598.  
  599.     hFile = (HFILE) GetTokenVal (lptArg-1);
  600.     wAmount = (UINT) GetTokenVal (lptArg-2);
  601.  
  602.     pbData = (PBYTE) LocalAlloc (LPTR, wAmount+2);
  603.     if (pbData == 0) {
  604.        sRC = ERR_OUT_OF_MEMORY;
  605.         SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  606.     } else {
  607.         wAmount = _lread (hFile, pbData, wAmount);
  608.         if (wAmount != 0) {
  609.             for (i = 0; i < wAmount; i++) 
  610.                 if (*(pbData+i) == '\0')
  611.                     *(pbData+i) = ' ';
  612.             *(pbData+i) = '\0';
  613.               sRC = SetToken (lptDest, TTYPE_STR, wAmount, (DWORD)(LPBYTE)pbData);
  614.         } else
  615.             sRC = SetToken (lptDest, TTYPE_NUM, 0, -1);
  616.         LocalFree ((HLOCAL)pbData);        
  617.     }
  618.       return sRC;
  619. }      
  620. //-----------------------------------------------------------
  621. // LibFileReadLine - Reads a line from a file
  622. // Arg 1 - File handle
  623. //----------------------------------------------------------- 
  624. INT LibFileReadLine (LPTOKEN lptDest, LPTOKEN lptArg) {
  625.    INT        sRC = 0;
  626.    UINT        i, wAmount;
  627.    HFILE        hFile;
  628.    PBYTE        pbData;
  629.    
  630.     if (lptDest->wData <= 1)
  631.         return ERR_TOO_FEW_PARMS;
  632.     hFile = (HFILE) GetTokenVal (lptArg-1);
  633.  
  634.     pbData = (PBYTE) LocalAlloc (LPTR, MAXREADLINE);
  635.     if (pbData == 0) {
  636.        sRC = ERR_OUT_OF_MEMORY;
  637.         SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  638.     } else {
  639.         wAmount = _lread (hFile, pbData, MAXREADLINE);
  640.         if (wAmount != 0) {
  641.             for (i = 0; i < wAmount-2; i++) {
  642.                 if (*(pbData+i) == '\0')
  643.                     *(pbData+i) = ' ';
  644.                 if (*(pbData+i) == 0x0d)
  645.                     break;
  646.             }
  647.             *(pbData+i) = '\0';
  648.             i++;
  649.             if (*(pbData+i) == 0x0a)
  650.                i++;
  651.             _llseek (hFile, (LONG)i - wAmount, 1);
  652.               sRC = SetToken (lptDest, TTYPE_STR, wAmount, (DWORD)(LPBYTE)pbData);
  653.         } else
  654.             sRC = SetToken (lptDest, TTYPE_NUM, 0, -1);
  655.         LocalFree ((HLOCAL)pbData);        
  656.     }
  657.       return sRC;
  658. }      
  659. //-----------------------------------------------------------
  660. // LibFileWrite - Function to write data to a file
  661. // Arg 1 - File handle
  662. // Arg 2 - Data to write
  663. //----------------------------------------------------------- 
  664. INT LibFileWrite(LPTOKEN lptDest, LPTOKEN lptArg) {
  665.    INT        sRC = 0;
  666.    HFILE        hFile;
  667.    
  668.     if (lptDest->wData <= 2) 
  669.         return ERR_TOO_FEW_PARMS;
  670.  
  671.    hFile = (HFILE) GetTokenVal (lptArg-1);
  672.    lstrcpy (szTemp, GetTokenString (lptArg-2));
  673.     sRC = _lwrite (hFile, szTemp, strlen (szTemp));
  674.  
  675.    if (sRC != HFILE_ERROR)
  676.        sRC = SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  677.     else
  678.         sRC = SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  679.       return sRC;
  680. }      
  681. //-----------------------------------------------------------
  682. // LibFileWriteLine - Function to write a line to a file
  683. // Arg 1 - File handle
  684. // Arg 2 - Data to write
  685. //----------------------------------------------------------- 
  686. INT LibFileWriteLine (LPTOKEN lptDest, LPTOKEN lptArg) {
  687.    INT        sRC = 0;
  688.    HFILE        hFile;
  689.    
  690.     if (lptDest->wData <= 2) 
  691.         return ERR_TOO_FEW_PARMS;
  692.  
  693.    hFile = (HFILE) GetTokenVal (lptArg-1);
  694.    lstrcpy (szTemp, GetTokenString (lptArg-2));
  695.     sRC = _lwrite (hFile, szTemp, strlen (szTemp));
  696.     if (sRC != HFILE_ERROR) {
  697.        sRC = 0x0a0d;
  698.         _lwrite (hFile, &sRC, 2);
  699.        sRC = SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  700.     } else
  701.         sRC = SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  702.       return sRC;
  703. }      
  704. //-----------------------------------------------------------
  705. // LibFileSeek - Function to move the file pointer 
  706. // Arg 1 - File handle
  707. // Arg 1 - Offset
  708. // Arg 1 - Seek mode
  709. //----------------------------------------------------------- 
  710. INT LibFileSeek(LPTOKEN lptDest, LPTOKEN lptArg) {
  711.    INT    sFlags;
  712.    HFILE    hFile;
  713.    LONG    lPtr;
  714.    
  715.     if (lptDest->wData <= 3) 
  716.         return ERR_TOO_FEW_PARMS;
  717.  
  718.    hFile = (HFILE) GetTokenVal (lptArg-1);
  719.    lPtr = GetTokenVal (lptArg-2);
  720.    sFlags = (INT) GetTokenVal (lptArg-3);
  721.    if (sFlags > 2)
  722.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  723.  
  724.     lPtr = _llseek (hFile, lPtr, sFlags);
  725.     return SetToken (lptDest, TTYPE_NUM, 0, (DWORD)lPtr);
  726. }      
  727. //-----------------------------------------------------------
  728. // LibFileClose - Function to close a file
  729. // Arg 1 - File handle
  730. //----------------------------------------------------------- 
  731. INT LibFileClose (LPTOKEN lptDest, LPTOKEN lptArg) {
  732.    INT        sRC = 0;
  733.    HFILE        hFile;
  734.    
  735.     if (lptDest->wData <= 1) 
  736.         return ERR_TOO_FEW_PARMS;
  737.  
  738.    hFile = (HFILE) GetTokenVal (lptArg-1);
  739.    if (_lclose (hFile) == 0)
  740.        sRC = SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  741.     else
  742.         sRC = SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  743.       return sRC;
  744. }      
  745. //-----------------------------------------------------------
  746. // Clipboard functions
  747. //----------------------------------------------------------- 
  748. //-----------------------------------------------------------
  749. // LibGetClipText - Function to return text from the clipboard
  750. //----------------------------------------------------------- 
  751. INT LibGetClipText (LPTOKEN lptDest, LPTOKEN lptArg) {
  752.    INT        sRC = 0;
  753.    HANDLE    hClip;
  754.    LPSTR        lpszClipText;
  755.    
  756.     if (!OpenClipboard(hMain))
  757.        return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  758.  
  759.     hClip = GetClipboardData (CF_TEXT);
  760.     if (hClip == 0) {
  761.        CloseClipboard ();
  762.        return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  763.     }
  764.     lpszClipText = (LPSTR) GlobalLock (hClip);
  765.     if (lpszClipText == 0) {
  766.        CloseClipboard ();
  767.        return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  768.     }
  769.     sRC = SetToken (lptDest, TTYPE_STR, 0, (DWORD)lpszClipText);
  770.     GlobalUnlock (hClip);
  771.    CloseClipboard ();
  772.       return sRC;
  773. }      
  774. //-----------------------------------------------------------
  775. // LibSetClipText - Function to copy text into the clipboard
  776. // Arg 1 - Text to copy to clipboard
  777. //----------------------------------------------------------- 
  778. INT LibSetClipText (LPTOKEN lptDest, LPTOKEN lptArg) {
  779.    INT        sRC = 0, i, sLen;
  780.    HANDLE    hClip;
  781.    LPSTR        lpszClipText, lpszPtr;
  782.    
  783.     if (lptDest->wData <= 1) 
  784.         return ERR_TOO_FEW_PARMS;
  785.  
  786.    lpszClipText = GetTokenString (lptArg-1);
  787.    
  788.     sLen = lstrlen (lpszClipText);
  789.     hClip = GlobalAlloc (GHND, sLen+1);
  790.     if (hClip == 0) {
  791.        sRC = ERR_OUT_OF_MEMORY;
  792.         return sRC;
  793.     }    
  794.     lpszPtr = (LPSTR) GlobalLock (hClip);
  795.     for (i = 0; i <= sLen; i++)
  796.        *lpszPtr++ = *lpszClipText++;
  797.     GlobalUnlock (hClip);
  798.     
  799.     if (!OpenClipboard(hMain)) {
  800.        GlobalFree (hClip);
  801.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  802.     }
  803.     if (SetClipboardData (CF_TEXT, hClip) == 0) 
  804.        sRC = SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  805.     else
  806.           sRC = SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  807.    CloseClipboard ();
  808.       return sRC;
  809. }
  810. //-----------------------------------------------------------
  811. // LibPostMessage - Function to post a message to a window
  812. // Arg 1 - Window handle
  813. // Arg 2 - Message number
  814. // Arg 3 - wParam
  815. // Arg 4 - lParam
  816. //----------------------------------------------------------- 
  817. INT LibPostMessage (LPTOKEN lptDest, LPTOKEN lptArg) {
  818.    HWND        hWnd;
  819.    UINT        wMsg, wParam;
  820.    LONG        lParam;
  821.    
  822.     if (lptDest->wData <= 4) 
  823.         return ERR_TOO_FEW_PARMS;
  824.  
  825.    hWnd = (HWND) GetTokenVal (lptArg-1);
  826.    wMsg = (UINT) GetTokenVal (lptArg-2);
  827.    wParam = (UINT) GetTokenVal (lptArg-3);
  828.    lParam = GetTokenVal (lptArg-4);
  829.       return SetToken (lptDest, TTYPE_NUM, 0, 
  830.                        (DWORD) PostMessage (hWnd, wMsg, wParam, lParam));   
  831. }
  832. //-----------------------------------------------------------
  833. // LibSendMessage - Function to send a message to a window
  834. // Arg 1 - Window handle
  835. // Arg 2 - Message number
  836. // Arg 3 - wParam
  837. // Arg 4 - lParam
  838. //----------------------------------------------------------- 
  839. INT LibSendMessage (LPTOKEN lptDest, LPTOKEN lptArg) {
  840.    HWND        hWnd;
  841.    UINT        wMsg, wParam;
  842.    LONG        lParam;
  843.    
  844.     if (lptDest->wData <= 4) 
  845.         return ERR_TOO_FEW_PARMS;
  846.  
  847.    hWnd = (HWND) GetTokenVal (lptArg-1);
  848.    wMsg = (UINT) GetTokenVal (lptArg-2);
  849.    wParam = (UINT) GetTokenVal (lptArg-3);
  850.    lParam = GetTokenVal (lptArg-4);
  851.       return SetToken (lptDest, TTYPE_NUM, 0, 
  852.                        (DWORD) SendMessage (hWnd, wMsg, wParam, lParam));   
  853. }
  854. //-----------------------------------------------------------
  855. // LibSendMCIString - Function that sends an MCI command string to
  856. // the Windows Multimedia drivers.
  857. // Arg 1 - MCI Command String
  858. //----------------------------------------------------------- 
  859. INT LibSendMCIString (LPTOKEN lptDest, LPTOKEN lptArg) {
  860.    DWORD    dwResult;
  861.  
  862.     if (lptDest->wData <= 1) 
  863.         return ERR_TOO_FEW_PARMS;
  864.    
  865.    szTemp[0] = '\0';
  866.    dwResult = mciSendString (GetTokenString (lptArg-1), szTemp, sizeof (szTemp), hMain);
  867.     if (dwResult) {
  868.        strcpy (szTemp, "ERROR ");
  869.        ltoa (dwResult, &szTemp[strlen (szTemp)], 10);
  870.     }  
  871. return SetToken (lptDest, TTYPE_STR, 0, (DWORD) (LPSTR) szTemp);   
  872. }
  873. //-----------------------------------------------------------
  874. // LibGetMCIErrString - Function that querys MCI for an error
  875. // string
  876. // Arg 1 - MCI Error code
  877. //----------------------------------------------------------- 
  878. INT LibGetMCIErrString (LPTOKEN lptDest, LPTOKEN lptArg) {
  879.    DWORD    dwResult;
  880.  
  881.     if (lptDest->wData <= 1) 
  882.         return ERR_TOO_FEW_PARMS;
  883.    
  884.    szTemp[0] = '\0';
  885.    dwResult = mciGetErrorString (GetTokenVal (lptArg-1), szTemp, sizeof (szTemp));
  886.     if (!dwResult)    
  887.         return SetToken (lptDest, TTYPE_STR, 0, 0);   
  888.     return SetToken (lptDest, TTYPE_STR, 0, (DWORD) (LPSTR) szTemp);   
  889. }
  890. //----------------------------------------------------------------------
  891. // Read File - Allocates a buff in global memory and reads in a file
  892. //----------------------------------------------------------------------
  893. HANDLE LoadFile (LPSTR szFileName) {
  894.    
  895.     OFSTRUCT    ofFile;
  896.     HFILE        hFileHandle;
  897.     HANDLE    hFileBuff;
  898.     UINT        wBytesRead;
  899.     LPBYTE     lpbFileBuff;
  900.  
  901.     hFileBuff = GlobalAlloc (GMEM_MOVEABLE | GMEM_ZEROINIT, 65535);
  902.     
  903.     if (hFileBuff == 0) return 0;
  904.     lpbFileBuff = GlobalLock (hFileBuff);
  905.  
  906.     hFileHandle = OpenFile (szFileName, &ofFile, OF_READ);
  907.     if (hFileHandle == -1) {
  908.        GlobalUnlock (hFileBuff);
  909.        GlobalFree (hFileBuff);
  910.        return ERR_FOPEN_ERR - ofFile.nErrCode;
  911.     }
  912.     wBytesRead = _lread (hFileHandle, lpbFileBuff, (WORD)65534);
  913.     _lclose (hFileHandle);
  914.  
  915.     if (wBytesRead == 65534) {
  916.        GlobalUnlock (hFileBuff);
  917.        GlobalFree (hFileBuff);
  918.        return ERR_FILE_TOO_BIG;
  919.     }
  920.     *(lpbFileBuff + wBytesRead) = 0;
  921.    GlobalUnlock (hFileBuff);
  922.    GlobalReAlloc (hFileBuff, wBytesRead+1, 0);
  923.    return hFileBuff;
  924. }
  925. //-----------------------------------------------------------
  926. // LibSetWinIcon - Function to set a window's icon
  927. // Arg 1 - Window handle
  928. //----------------------------------------------------------- 
  929. INT LibSetWinIcon (LPTOKEN lptDest, LPTOKEN lptArg) {
  930.    HWND        hWnd;
  931.    UINT        hIcon;
  932.    
  933.     if (lptDest->wData <= 2) 
  934.         return ERR_TOO_FEW_PARMS;
  935.  
  936.    hWnd = (HWND) GetTokenVal (lptArg-1);
  937.    hIcon = (WORD) GetTokenVal (lptArg-2);
  938.       hIcon = SetClassWord (hWnd, GCW_HICON, hIcon);
  939.     if (IsIconic (hWnd)) {
  940.         // Do this to force Windows to redraw the icon
  941.         ShowWindow (hWnd, SW_HIDE);
  942.         ShowWindow (hWnd, SW_SHOW);
  943.     }
  944.       return SetToken (lptDest, TTYPE_NUM, 0, hIcon);
  945. }
  946. //-----------------------------------------------------------
  947. // LibLoadIconFile - Function that reads in an Icon file
  948. // Arg 1 - File Name
  949. // Arg 2 - Icon number to return (Default 1)
  950. //----------------------------------------------------------- 
  951. INT LibLoadIconFile (LPTOKEN lptDest, LPTOKEN lptArg) {
  952.     HICON        hIcon;
  953.     INT        sSelIcon = 0;
  954.  
  955.     if (lptDest->wData <= 1) 
  956.         return ERR_TOO_FEW_PARMS;
  957.     
  958.     if (lptDest->wData > 2)
  959.         sSelIcon = (INT) GetTokenVal (lptArg-2);
  960.     
  961.     hIcon = ExtractIcon (hInst,GetTokenString (lptArg-1), sSelIcon);
  962.       return SetToken (lptDest, TTYPE_NUM, 0, (DWORD) hIcon);
  963. }
  964. //-----------------------------------------------------------
  965. // LibGetCWD - Function that returns the current directory
  966. //----------------------------------------------------------- 
  967. INT LibGetCWD (LPTOKEN lptDest, LPTOKEN lptArg) {
  968.  
  969.     getcwd (szTemp, sizeof (szTemp));    
  970.       return SetToken (lptDest, TTYPE_STR, 0, (DWORD)(LPSTR)szTemp);
  971. }
  972. //-----------------------------------------------------------
  973. // LibChDrive - Function that changes the default drive
  974. // Arg 1 - Drive letter
  975. //----------------------------------------------------------- 
  976. INT LibChDrive (LPTOKEN lptDest, LPTOKEN lptArg) {
  977.  
  978.     if (lptDest->wData <= 1) 
  979.         return ERR_TOO_FEW_PARMS;
  980.  
  981.     if (_chdrive (*(GetTokenString (lptArg-1))-0x40) == 0)
  982.         return SetToken (lptDest, TTYPE_NUM, 0, MYTRUE);
  983.     else
  984.         return SetToken (lptDest, TTYPE_NUM, 0, MYFALSE);
  985.     }
  986.  
  987.